[−][src]Trait fire::common::ParallelIterator
Parallel version of the standard iterator trait.
The combinators on this trait are available on all parallel
iterators. Additional methods can be found on the
IndexedParallelIterator trait: those methods are only
available for parallel iterators where the number of items is
known in advance (so, e.g., after invoking filter, those methods
become unavailable).
For examples of using parallel iterators, see the docs on the
iter module.
Associated Types
type Item: Send
The type of item that this parallel iterator produces.
For example, if you use the for_each method, this is the type of
item that your closure will be invoked with.
Required methods
fn drive_unindexed<C>(self, consumer: C) -> <C as Consumer<Self::Item>>::Result where
C: UnindexedConsumer<Self::Item>,
C: UnindexedConsumer<Self::Item>,
Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.
This method causes the iterator self to start producing
items and to feed them to the consumer consumer one by one.
It may split the consumer before doing so to create the
opportunity to produce in parallel.
See the README for more details on the internals of parallel iterators.
Provided methods
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
OP: Fn(Self::Item) + Sync + Send,
Executes OP on each item produced by the iterator, in parallel.
Examples
use rayon::prelude::*; (0..100).into_par_iter().for_each(|x| println!("{:?}", x));
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
Executes OP on the given init value with each item produced by
the iterator, in parallel.
The init value will be cloned only as needed to be paired with
the group of items in each rayon job. It does not require the type
to be Sync.
Examples
use std::sync::mpsc::channel; use rayon::prelude::*; let (sender, receiver) = channel(); (0..5).into_par_iter().for_each_with(sender, |s, x| s.send(x).unwrap()); let mut res: Vec<_> = receiver.iter().collect(); res.sort(); assert_eq!(&res[..], &[0, 1, 2, 3, 4])
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
INIT: Fn() -> T + Sync + Send,
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
OP: Fn(&mut T, Self::Item) + Sync + Send,
Executes OP on a value returned by init with each item produced by
the iterator, in parallel.
The init function will be called only as needed for a value to be
paired with the group of items in each rayon job. There is no
constraint on that returned type at all!
Examples
extern crate rand; extern crate rayon; use rand::Rng; use rayon::prelude::*; let mut v = vec![0u8; 1_000_000]; v.par_chunks_mut(1000) .for_each_init( || rand::thread_rng(), |rng, chunk| rng.fill(chunk), ); // There's a remote chance that this will fail... for i in 0u8..=255 { assert!(v.contains(&i)); }
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
Executes a fallible OP on each item produced by the iterator, in parallel.
If the OP returns Result::Err or Option::None, we will attempt to
stop processing the rest of the items in the iterator as soon as
possible, and we will return that terminating value. Otherwise, we will
return an empty Result::Ok(()) or Option::Some(()). If there are
multiple errors in parallel, it is not specified which will be returned.
Examples
use rayon::prelude::*; use std::io::{self, Write}; // This will stop iteration early if there's any write error, like // having piped output get closed on the other end. (0..100).into_par_iter() .try_for_each(|x| writeln!(io::stdout(), "{:?}", x)) .expect("expected no write errors");
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
T: Send + Clone,
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
T: Send + Clone,
Executes a fallible OP on the given init value with each item
produced by the iterator, in parallel.
This combines the init semantics of for_each_with() and the
failure semantics of try_for_each().
Examples
use std::sync::mpsc::channel; use rayon::prelude::*; let (sender, receiver) = channel(); (0..5).into_par_iter() .try_for_each_with(sender, |s, x| s.send(x)) .expect("expected no send errors"); let mut res: Vec<_> = receiver.iter().collect(); res.sort(); assert_eq!(&res[..], &[0, 1, 2, 3, 4])
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
INIT: Fn() -> T + Sync + Send,
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
INIT: Fn() -> T + Sync + Send,
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
Executes a fallible OP on a value returned by init with each item
produced by the iterator, in parallel.
This combines the init semantics of for_each_init() and the
failure semantics of try_for_each().
Examples
extern crate rand; extern crate rayon; use rand::Rng; use rayon::prelude::*; let mut v = vec![0u8; 1_000_000]; v.par_chunks_mut(1000) .try_for_each_init( || rand::thread_rng(), |rng, chunk| rng.try_fill(chunk), ) .expect("expected no rand errors"); // There's a remote chance that this will fail... for i in 0u8..=255 { assert!(v.contains(&i)); }
fn count(self) -> usize
Counts the number of items in this parallel iterator.
Examples
use rayon::prelude::*; let count = (0..100).into_par_iter().count(); assert_eq!(count, 100);
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
Applies map_op to each item of this iterator, producing a new
iterator with the results.
Examples
use rayon::prelude::*; let mut par_iter = (0..5).into_par_iter().map(|x| x * 2); let doubles: Vec<_> = par_iter.collect(); assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
R: Send,
T: Send + Clone,
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
R: Send,
T: Send + Clone,
Applies map_op to the given init value with each item of this
iterator, producing a new iterator with the results.
The init value will be cloned only as needed to be paired with
the group of items in each rayon job. It does not require the type
to be Sync.
Examples
use std::sync::mpsc::channel; use rayon::prelude::*; let (sender, receiver) = channel(); let a: Vec<_> = (0..5) .into_par_iter() // iterating over i32 .map_with(sender, |s, x| { s.send(x).unwrap(); // sending i32 values through the channel x // returning i32 }) .collect(); // collecting the returned values into a vector let mut b: Vec<_> = receiver.iter() // iterating over the values in the channel .collect(); // and collecting them b.sort(); assert_eq!(a, b);
fn map_init<F, INIT, T, R>(
self,
init: INIT,
map_op: F
) -> MapInit<Self, INIT, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
self,
init: INIT,
map_op: F
) -> MapInit<Self, INIT, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
Applies map_op to a value returned by init with each item of this
iterator, producing a new iterator with the results.
The init function will be called only as needed for a value to be
paired with the group of items in each rayon job. There is no
constraint on that returned type at all!
Examples
extern crate rand; extern crate rayon; use rand::Rng; use rayon::prelude::*; let a: Vec<_> = (1i32..1_000_000) .into_par_iter() .map_init( || rand::thread_rng(), // get the thread-local RNG |rng, x| if rng.gen() { // randomly negate items -x } else { x }, ).collect(); // There's a remote chance that this will fail... assert!(a.iter().any(|&x| x < 0)); assert!(a.iter().any(|&x| x > 0));
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: ParallelIterator<Item = &'a T>,
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
T: 'a + Clone + Send,
Creates an iterator which clones all of its elements. This may be
useful when you have an iterator over &T, but you need T.
Examples
use rayon::prelude::*; let a = [1, 2, 3]; let v_cloned: Vec<_> = a.par_iter().cloned().collect(); // cloned is the same as .map(|&x| x), for integers let v_map: Vec<_> = a.par_iter().map(|&x| x).collect(); assert_eq!(v_cloned, vec![1, 2, 3]); assert_eq!(v_map, vec![1, 2, 3]);
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
OP: Fn(&Self::Item) + Sync + Send,
OP: Fn(&Self::Item) + Sync + Send,
Applies inspect_op to a reference to each item of this iterator,
producing a new iterator passing through the original items. This is
often useful for debugging to see what's happening in iterator stages.
Examples
use rayon::prelude::*; let a = [1, 4, 2, 3]; // this iterator sequence is complex. let sum = a.par_iter() .cloned() .filter(|&x| x % 2 == 0) .reduce(|| 0, |sum, i| sum + i); println!("{}", sum); // let's add some inspect() calls to investigate what's happening let sum = a.par_iter() .cloned() .inspect(|x| println!("about to filter: {}", x)) .filter(|&x| x % 2 == 0) .inspect(|x| println!("made it through filter: {}", x)) .reduce(|| 0, |sum, i| sum + i); println!("{}", sum);
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
F: Fn(&mut Self::Item) + Sync + Send,
Mutates each item of this iterator before yielding it.
Examples
use rayon::prelude::*; let par_iter = (0..5).into_par_iter().update(|x| {*x *= 2;}); let doubles: Vec<_> = par_iter.collect(); assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
P: Fn(&Self::Item) -> bool + Sync + Send,
P: Fn(&Self::Item) -> bool + Sync + Send,
Applies filter_op to each item of this iterator, producing a new
iterator with only the items that gave true results.
Examples
use rayon::prelude::*; let mut par_iter = (0..10).into_par_iter().filter(|x| x % 2 == 0); let even_numbers: Vec<_> = par_iter.collect(); assert_eq!(&even_numbers[..], &[0, 2, 4, 6, 8]);
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
Applies filter_op to each item of this iterator to get an Option,
producing a new iterator with only the items from Some results.
Examples
use rayon::prelude::*; let mut par_iter = (0..10).into_par_iter() .filter_map(|x| { if x % 2 == 0 { Some(x * 3) } else { None } }); let even_numbers: Vec<_> = par_iter.collect(); assert_eq!(&even_numbers[..], &[0, 6, 12, 18, 24]);
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
Applies map_op to each item of this iterator to get nested iterators,
producing a new iterator that flattens these back into one.
Examples
use rayon::prelude::*; let a = [[1, 2], [3, 4], [5, 6], [7, 8]]; let par_iter = a.par_iter().cloned().flat_map(|a| a.to_vec()); let vec: Vec<_> = par_iter.collect(); assert_eq!(&vec[..], &[1, 2, 3, 4, 5, 6, 7, 8]);
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
Self::Item: IntoParallelIterator,
An adaptor that flattens iterable Items into one large iterator
Examples
use rayon::prelude::*; let x: Vec<Vec<_>> = vec![vec![1, 2], vec![3, 4]]; let y: Vec<_> = x.into_par_iter().flatten().collect(); assert_eq!(y, vec![1, 2, 3, 4]);
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
ID: Fn() -> Self::Item + Sync + Send,
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
Reduces the items in the iterator into one item using op.
The argument identity should be a closure that can produce
"identity" value which may be inserted into the sequence as
needed to create opportunities for parallel execution. So, for
example, if you are doing a summation, then identity() ought
to produce something that represents the zero for your type
(but consider just calling sum() in that case).
Examples
// Iterate over a sequence of pairs `(x0, y0), ..., (xN, yN)` // and use reduce to compute one pair `(x0 + ... + xN, y0 + ... + yN)` // where the first/second elements are summed separately. use rayon::prelude::*; let sums = [(0, 1), (5, 6), (16, 2), (8, 9)] .par_iter() // iterating over &(i32, i32) .cloned() // iterating over (i32, i32) .reduce(|| (0, 0), // the "identity" is 0 in both columns |a, b| (a.0 + b.0, a.1 + b.1)); assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));
Note: unlike a sequential fold operation, the order in
which op will be applied to reduce the result is not fully
specified. So op should be associative or else the results
will be non-deterministic. And of course identity() should
produce a true identity.
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
Reduces the items in the iterator into one item using op.
If the iterator is empty, None is returned; otherwise,
Some is returned.
This version of reduce is simple but somewhat less
efficient. If possible, it is better to call reduce(), which
requires an identity element.
Examples
use rayon::prelude::*; let sums = [(0, 1), (5, 6), (16, 2), (8, 9)] .par_iter() // iterating over &(i32, i32) .cloned() // iterating over (i32, i32) .reduce_with(|a, b| (a.0 + b.0, a.1 + b.1)) .unwrap(); assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));
Note: unlike a sequential fold operation, the order in
which op will be applied to reduce the result is not fully
specified. So op should be associative or else the results
will be non-deterministic.
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
ID: Fn() -> T + Sync + Send,
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try,
<Self::Item as Try>::Ok == T,
ID: Fn() -> T + Sync + Send,
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try,
<Self::Item as Try>::Ok == T,
Reduces the items in the iterator into one item using a fallible op.
The identity argument is used the same way as in reduce().
If a Result::Err or Option::None item is found, or if op reduces
to one, we will attempt to stop processing the rest of the items in the
iterator as soon as possible, and we will return that terminating value.
Otherwise, we will return the final reduced Result::Ok(T) or
Option::Some(T). If there are multiple errors in parallel, it is not
specified which will be returned.
Examples
use rayon::prelude::*; // Compute the sum of squares, being careful about overflow. fn sum_squares<I: IntoParallelIterator<Item = i32>>(iter: I) -> Option<i32> { iter.into_par_iter() .map(|i| i.checked_mul(i)) // square each item, .try_reduce(|| 0, i32::checked_add) // and add them up! } assert_eq!(sum_squares(0..5), Some(0 + 1 + 4 + 9 + 16)); // The sum might overflow assert_eq!(sum_squares(0..10_000), None); // Or the squares might overflow before it even reaches `try_reduce` assert_eq!(sum_squares(1_000_000..1_000_001), None);
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try,
<Self::Item as Try>::Ok == T,
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try,
<Self::Item as Try>::Ok == T,
Reduces the items in the iterator into one item using a fallible op.
Like reduce_with(), if the iterator is empty, None is returned;
otherwise, Some is returned. Beyond that, it behaves like
try_reduce() for handling Err/None.
For instance, with Option items, the return value may be:
None, the iterator was emptySome(None), we stopped after encounteringNone.Some(Some(x)), the entire iterator reduced tox.
With Result items, the nesting is more obvious:
None, the iterator was emptySome(Err(e)), we stopped after encountering an errore.Some(Ok(x)), the entire iterator reduced tox.
Examples
use rayon::prelude::*; let files = ["/dev/null", "/does/not/exist"]; // Find the biggest file files.into_par_iter() .map(|path| std::fs::metadata(path).map(|m| (path, m.len()))) .try_reduce_with(|a, b| { Ok(if a.1 >= b.1 { a } else { b }) }) .expect("Some value, since the iterator is not empty") .expect_err("not found");
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
Parallel fold is similar to sequential fold except that the
sequence of items may be subdivided before it is
folded. Consider a list of numbers like 22 3 77 89 46. If
you used sequential fold to add them (fold(0, |a,b| a+b),
you would wind up first adding 0 + 22, then 22 + 3, then 25 +
77, and so forth. The parallel fold works similarly except
that it first breaks up your list into sublists, and hence
instead of yielding up a single sum at the end, it yields up
multiple sums. The number of results is nondeterministic, as
is the point where the breaks occur.
So if did the same parallel fold (fold(0, |a,b| a+b)) on
our example list, we might wind up with a sequence of two numbers,
like so:
22 3 77 89 46
| |
102 135
Or perhaps these three numbers:
22 3 77 89 46
| | |
102 89 46
In general, Rayon will attempt to find good breaking points that keep all of your cores busy.
Fold versus reduce
The fold() and reduce() methods each take an identity element
and a combining function, but they operate rather differently.
reduce() requires that the identity function has the same
type as the things you are iterating over, and it fully
reduces the list of items into a single item. So, for example,
imagine we are iterating over a list of bytes bytes: [128_u8, 64_u8, 64_u8]. If we used bytes.reduce(|| 0_u8, |a: u8, b: u8| a + b), we would get an overflow. This is because 0,
a, and b here are all bytes, just like the numbers in the
list (I wrote the types explicitly above, but those are the
only types you can use). To avoid the overflow, we would need
to do something like bytes.map(|b| b as u32).reduce(|| 0, |a, b| a + b), in which case our result would be 256.
In contrast, with fold(), the identity function does not
have to have the same type as the things you are iterating
over, and you potentially get back many results. So, if we
continue with the bytes example from the previous paragraph,
we could do bytes.fold(|| 0_u32, |a, b| a + (b as u32)) to
convert our bytes into u32. And of course we might not get
back a single sum.
There is a more subtle distinction as well, though it's
actually implied by the above points. When you use reduce(),
your reduction function is sometimes called with values that
were never part of your original parallel iterator (for
example, both the left and right might be a partial sum). With
fold(), in contrast, the left value in the fold function is
always the accumulator, and the right value is always from
your original sequence.
Fold vs Map/Reduce
Fold makes sense if you have some operation where it is cheaper to create groups of elements at a time. For example, imagine collecting characters into a string. If you were going to use map/reduce, you might try this:
use rayon::prelude::*; let s = ['a', 'b', 'c', 'd', 'e'] .par_iter() .map(|c: &char| format!("{}", c)) .reduce(|| String::new(), |mut a: String, b: String| { a.push_str(&b); a }); assert_eq!(s, "abcde");
Because reduce produces the same type of element as its input,
you have to first map each character into a string, and then
you can reduce them. This means we create one string per
element in our iterator -- not so great. Using fold, we can
do this instead:
use rayon::prelude::*; let s = ['a', 'b', 'c', 'd', 'e'] .par_iter() .fold(|| String::new(), |mut s: String, c: &char| { s.push(*c); s }) .reduce(|| String::new(), |mut a: String, b: String| { a.push_str(&b); a }); assert_eq!(s, "abcde");
Now fold will process groups of our characters at a time,
and we only make one string per group. We should wind up with
some small-ish number of strings roughly proportional to the
number of CPUs you have (it will ultimately depend on how busy
your processors are). Note that we still need to do a reduce
afterwards to combine those groups of strings into a single
string.
You could use a similar trick to save partial results (e.g., a cache) or something similar.
Combining fold with other operations
You can combine fold with reduce if you want to produce a
single value. This is then roughly equivalent to a map/reduce
combination in effect:
use rayon::prelude::*; let bytes = 0..22_u8; let sum = bytes.into_par_iter() .fold(|| 0_u32, |a: u32, b: u8| a + (b as u32)) .sum::<u32>(); assert_eq!(sum, (0..22).sum()); // compare to sequential
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
Applies fold_op to the given init value with each item of this
iterator, finally producing the value for further use.
This works essentially like fold(|| init.clone(), fold_op), except
it doesn't require the init type to be Sync, nor any other form
of added synchronization.
Examples
use rayon::prelude::*; let bytes = 0..22_u8; let sum = bytes.into_par_iter() .fold_with(0_u32, |a: u32, b: u8| a + (b as u32)) .sum::<u32>(); assert_eq!(sum, (0..22).sum()); // compare to sequential
fn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Ok = T> + Send,
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Ok = T> + Send,
Perform a fallible parallel fold.
This is a variation of fold() for operations which can fail with
Option::None or Result::Err. The first such failure stops
processing the local set of items, without affecting other folds in the
iterator's subdivisions.
Often, try_fold() will be followed by try_reduce()
for a final reduction and global short-circuiting effect.
Examples
use rayon::prelude::*; let bytes = 0..22_u8; let sum = bytes.into_par_iter() .try_fold(|| 0_u32, |a: u32, b: u8| a.checked_add(b as u32)) .try_reduce(|| 0, u32::checked_add); assert_eq!(sum, Some((0..22).sum())); // compare to sequential
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
Perform a fallible parallel fold with a cloneable init value.
This combines the init semantics of fold_with() and the failure
semantics of try_fold().
use rayon::prelude::*; let bytes = 0..22_u8; let sum = bytes.into_par_iter() .try_fold_with(0_u32, |a: u32, b: u8| a.checked_add(b as u32)) .try_reduce(|| 0, u32::checked_add); assert_eq!(sum, Some((0..22).sum())); // compare to sequential
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
S: Send + Sum<Self::Item> + Sum<S>,
Sums up the items in the iterator.
Note that the order in items will be reduced is not specified,
so if the + operator is not truly associative (as is the
case for floating point numbers), then the results are not
fully deterministic.
Basically equivalent to self.reduce(|| 0, |a, b| a + b),
except that the type of 0 and the + operation may vary
depending on the type of value being produced.
Examples
use rayon::prelude::*; let a = [1, 5, 7]; let sum: i32 = a.par_iter().sum(); assert_eq!(sum, 13);
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
P: Send + Product<Self::Item> + Product<P>,
Multiplies all the items in the iterator.
Note that the order in items will be reduced is not specified,
so if the * operator is not truly associative (as is the
case for floating point numbers), then the results are not
fully deterministic.
Basically equivalent to self.reduce(|| 1, |a, b| a * b),
except that the type of 1 and the * operation may vary
depending on the type of value being produced.
Examples
use rayon::prelude::*; fn factorial(n: u32) -> u32 { (1..n+1).into_par_iter().product() } assert_eq!(factorial(0), 1); assert_eq!(factorial(1), 1); assert_eq!(factorial(5), 120);
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
Self::Item: Ord,
Computes the minimum of all the items in the iterator. If the
iterator is empty, None is returned; otherwise, Some(min)
is returned.
Note that the order in which the items will be reduced is not
specified, so if the Ord impl is not truly associative, then
the results are not deterministic.
Basically equivalent to self.reduce_with(|a, b| cmp::min(a, b)).
Examples
use rayon::prelude::*; let a = [45, 74, 32]; assert_eq!(a.par_iter().min(), Some(&32)); let b: [i32; 0] = []; assert_eq!(b.par_iter().min(), None);
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
Computes the minimum of all the items in the iterator with respect to
the given comparison function. If the iterator is empty, None is
returned; otherwise, Some(min) is returned.
Note that the order in which the items will be reduced is not specified, so if the comparison function is not associative, then the results are not deterministic.
Examples
use rayon::prelude::*; let a = [-3_i32, 77, 53, 240, -1]; assert_eq!(a.par_iter().min_by(|x, y| x.cmp(y)), Some(&-3));
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item) -> K,
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
K: Ord + Send,
Computes the item that yields the minimum value for the given
function. If the iterator is empty, None is returned;
otherwise, Some(item) is returned.
Note that the order in which the items will be reduced is not
specified, so if the Ord impl is not truly associative, then
the results are not deterministic.
Examples
use rayon::prelude::*; let a = [-3_i32, 34, 2, 5, -10, -3, -23]; assert_eq!(a.par_iter().min_by_key(|x| x.abs()), Some(&2));
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
Self::Item: Ord,
Computes the maximum of all the items in the iterator. If the
iterator is empty, None is returned; otherwise, Some(max)
is returned.
Note that the order in which the items will be reduced is not
specified, so if the Ord impl is not truly associative, then
the results are not deterministic.
Basically equivalent to self.reduce_with(|a, b| cmp::max(a, b)).
Examples
use rayon::prelude::*; let a = [45, 74, 32]; assert_eq!(a.par_iter().max(), Some(&74)); let b: [i32; 0] = []; assert_eq!(b.par_iter().max(), None);
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
Computes the maximum of all the items in the iterator with respect to
the given comparison function. If the iterator is empty, None is
returned; otherwise, Some(min) is returned.
Note that the order in which the items will be reduced is not specified, so if the comparison function is not associative, then the results are not deterministic.
Examples
use rayon::prelude::*; let a = [-3_i32, 77, 53, 240, -1]; assert_eq!(a.par_iter().max_by(|x, y| x.abs().cmp(&y.abs())), Some(&240));
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item) -> K,
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
K: Ord + Send,
Computes the item that yields the maximum value for the given
function. If the iterator is empty, None is returned;
otherwise, Some(item) is returned.
Note that the order in which the items will be reduced is not
specified, so if the Ord impl is not truly associative, then
the results are not deterministic.
Examples
use rayon::prelude::*; let a = [-3_i32, 34, 2, 5, -10, -3, -23]; assert_eq!(a.par_iter().max_by_key(|x| x.abs()), Some(&34));
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
C: IntoParallelIterator<Item = Self::Item>,
Takes two iterators and creates a new iterator over both.
Examples
use rayon::prelude::*; let a = [0, 1, 2]; let b = [9, 8, 7]; let par_iter = a.par_iter().chain(b.par_iter()); let chained: Vec<_> = par_iter.cloned().collect(); assert_eq!(&chained[..], &[0, 1, 2, 9, 8, 7]);
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
P: Fn(&Self::Item) -> bool + Sync + Send,
Searches for some item in the parallel iterator that
matches the given predicate and returns it. This operation
is similar to find on sequential iterators but
the item returned may not be the first one in the parallel
sequence which matches, since we search the entire sequence in parallel.
Once a match is found, we will attempt to stop processing
the rest of the items in the iterator as soon as possible
(just as find stops iterating once a match is found).
Examples
use rayon::prelude::*; let a = [1, 2, 3, 3]; assert_eq!(a.par_iter().find_any(|&&x| x == 3), Some(&3)); assert_eq!(a.par_iter().find_any(|&&x| x == 100), None);
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
P: Fn(&Self::Item) -> bool + Sync + Send,
Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it.
Once a match is found, all attempts to the right of the match will be stopped, while attempts to the left must continue in case an earlier match is found.
Note that not all parallel iterators have a useful order, much like
sequential HashMap iteration, so "first" may be nebulous. If you
just want the first match that discovered anywhere in the iterator,
find_any is a better choice.
Exmaples
use rayon::prelude::*; let a = [1, 2, 3, 3]; assert_eq!(a.par_iter().find_first(|&&x| x == 3), Some(&3)); assert_eq!(a.par_iter().find_first(|&&x| x == 100), None);
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
P: Fn(&Self::Item) -> bool + Sync + Send,
Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it.
Once a match is found, all attempts to the left of the match will be stopped, while attempts to the right must continue in case a later match is found.
Note that not all parallel iterators have a useful order, much like
sequential HashMap iteration, so "last" may be nebulous. When the
order doesn't actually matter to you, find_any is a better choice.
Examples
use rayon::prelude::*; let a = [1, 2, 3, 3]; assert_eq!(a.par_iter().find_last(|&&x| x == 3), Some(&3)); assert_eq!(a.par_iter().find_last(|&&x| x == 100), None);
fn find<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
P: Fn(&Self::Item) -> bool + Sync + Send,
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
P: Fn(Self::Item) -> bool + Sync + Send,
Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we'll attempt to stop process the rest of the items. Proving that there's no match, returning false, does require visiting every item.
Examples
use rayon::prelude::*; let a = [0, 12, 3, 4, 0, 23, 0]; let is_valid = a.par_iter().any(|&x| x > 10); assert!(is_valid);
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
P: Fn(Self::Item) -> bool + Sync + Send,
Tests that every item in the parallel iterator matches the given predicate, and if so returns true. If a counter-example is found, we'll attempt to stop processing more items, then return false.
Examples
use rayon::prelude::*; let a = [0, 12, 3, 4, 0, 23, 0]; let is_valid = a.par_iter().all(|&x| x > 10); assert!(!is_valid);
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
Self: ParallelIterator<Item = Option<T>>,
T: Send,
Creates an iterator over the Some items of this iterator, halting
as soon as any None is found.
Examples
use rayon::prelude::*; use std::sync::atomic::{AtomicUsize, Ordering}; let counter = AtomicUsize::new(0); let value = (0_i32..2048) .into_par_iter() .map(|x| { counter.fetch_add(1, Ordering::SeqCst); if x < 1024 { Some(x) } else { None } }) .while_some() .max(); assert!(value < Some(1024)); assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
C: FromParallelIterator<Self::Item>,
Create a fresh collection containing all the element produced by this parallel iterator.
You may prefer to use collect_into_vec(), which allocates more
efficiently with precise knowledge of how many elements the
iterator contains, and even allows you to reuse an existing
vector's backing store rather than allocating a fresh vector.
Examples
use rayon::prelude::*; let sync_vec: Vec<_> = (0..100).into_iter().collect(); let async_vec: Vec<_> = (0..100).into_par_iter().collect(); assert_eq!(sync_vec, async_vec);
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
A: Send,
B: Send,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
Self: ParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
Self: ParallelIterator<Item = (A, B)>,
Unzips the items of a parallel iterator into a pair of arbitrary
ParallelExtend containers.
You may prefer to use unzip_into_vecs(), which allocates more
efficiently with precise knowledge of how many elements the
iterator contains, and even allows you to reuse existing
vectors' backing stores rather than allocating fresh vectors.
Examples
use rayon::prelude::*; let a = [(0, 1), (1, 2), (2, 3), (3, 4)]; let (left, right): (Vec<_>, Vec<_>) = a.par_iter().cloned().unzip(); assert_eq!(left, [0, 1, 2, 3]); assert_eq!(right, [1, 2, 3, 4]);
Nested pairs can be unzipped too.
use rayon::prelude::*; let (values, (squares, cubes)): (Vec<_>, (Vec<_>, Vec<_>)) = (0..4).into_par_iter() .map(|i| (i, (i * i, i * i * i))) .unzip(); assert_eq!(values, [0, 1, 2, 3]); assert_eq!(squares, [0, 1, 4, 9]); assert_eq!(cubes, [0, 1, 8, 27]);
fn partition<A, B, P>(self, predicate: P) -> (A, B) where
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
Partitions the items of a parallel iterator into a pair of arbitrary
ParallelExtend containers. Items for which the predicate returns
true go into the first container, and the rest go into the second.
Note: unlike the standard Iterator::partition, this allows distinct
collection types for the left and right items. This is more flexible,
but may require new type annotations when converting sequential code
that used type inferrence assuming the two were the same.
Examples
use rayon::prelude::*; let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter().partition(|x| x % 2 == 0); assert_eq!(left, [0, 2, 4, 6]); assert_eq!(right, [1, 3, 5, 7]);
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
L: Send,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
R: Send,
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
L: Send,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
R: Send,
Partitions and maps the items of a parallel iterator into a pair of
arbitrary ParallelExtend containers. Either::Left items go into
the first container, and Either::Right items go into the second.
Examples
use rayon::prelude::*; use rayon::iter::Either; let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter() .partition_map(|x| { if x % 2 == 0 { Either::Left(x * 4) } else { Either::Right(x * 3) } }); assert_eq!(left, [0, 8, 16, 24]); assert_eq!(right, [3, 9, 15, 21]);
Nested Either enums can be split as well.
use rayon::prelude::*; use rayon::iter::Either::*; let ((fizzbuzz, fizz), (buzz, other)): ((Vec<_>, Vec<_>), (Vec<_>, Vec<_>)) = (1..20) .into_par_iter() .partition_map(|x| match (x % 3, x % 5) { (0, 0) => Left(Left(x)), (0, _) => Left(Right(x)), (_, 0) => Right(Left(x)), (_, _) => Right(Right(x)), }); assert_eq!(fizzbuzz, [15]); assert_eq!(fizz, [3, 6, 9, 12, 18]); assert_eq!(buzz, [5, 10]); assert_eq!(other, [1, 2, 4, 7, 8, 11, 13, 14, 16, 17, 19]);
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
Self::Item: Clone,
Intersperses clones of an element between items of this iterator.
Examples
use rayon::prelude::*; let x = vec![1, 2, 3]; let r: Vec<_> = x.into_par_iter().intersperse(-1).collect(); assert_eq!(r, vec![1, -1, 2, -1, 3]);
fn opt_len(&self) -> Option<usize>
Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.
Returns the number of items produced by this iterator, if known
statically. This can be used by consumers to trigger special fast
paths. Therefore, if Some(_) is returned, this iterator must only
use the (indexed) Consumer methods when driving a consumer, such
as split_at(). Calling UnindexedConsumer::split_off_left() or
other UnindexedConsumer methods -- or returning an inaccurate
value -- may result in panics.
This method is currently used to optimize collect for want
of true Rust specialization; it may be removed when
specialization is stable.
Implementations on Foreign Types
impl<I, T> ParallelIterator for WhileSome<I> where
I: ParallelIterator<Item = Option<T>>,
T: Send, [src]
impl<I, T> ParallelIterator for WhileSome<I> where
I: ParallelIterator<Item = Option<T>>,
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'data, T> ParallelIterator for ChunksMut<'data, T> where
T: 'data + Send, [src]
impl<'data, T> ParallelIterator for ChunksMut<'data, T> where
T: 'data + Send, type Item = &'data mut [T]
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch> ParallelIterator for SplitWhitespace<'ch>[src]
impl<'ch> ParallelIterator for SplitWhitespace<'ch>type Item = &'ch str
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send + Ord, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send + Ord, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync + Ord, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync + Ord, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'data, T> ParallelIterator for Iter<'data, T> where
T: 'data + Sync, [src]
impl<'data, T> ParallelIterator for Iter<'data, T> where
T: 'data + Sync, type Item = &'data T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch> ParallelIterator for CharIndices<'ch>[src]
impl<'ch> ParallelIterator for CharIndices<'ch>type Item = (usize, char)
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<I, F> ParallelIterator for Inspect<I, F> where
F: Fn(&<I as ParallelIterator>::Item) + Sync + Send,
I: ParallelIterator, [src]
impl<I, F> ParallelIterator for Inspect<I, F> where
F: Fn(&<I as ParallelIterator>::Item) + Sync + Send,
I: ParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<i32>[src]
impl ParallelIterator for Iter<i32>type Item = i32
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I> ParallelIterator for MinLen<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for MinLen<I> where
I: IndexedParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send + Ord, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send + Ord, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I> ParallelIterator for Chunks<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for Chunks<I> where
I: IndexedParallelIterator, type Item = Vec<<I as ParallelIterator>::Item>
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, [src]
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, type Item = &'a mut T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<U, I, F> ParallelIterator for FoldWith<I, U, F> where
F: Fn(U, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
U: Send + Clone, [src]
impl<U, I, F> ParallelIterator for FoldWith<I, U, F> where
F: Fn(U, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
U: Send + Clone, type Item = U
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<I> ParallelIterator for Take<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for Take<I> where
I: IndexedParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, [src]
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, type Item = &'a mut T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<A, B> ParallelIterator for Chain<A, B> where
A: ParallelIterator,
B: ParallelIterator<Item = <A as ParallelIterator>::Item>, [src]
impl<A, B> ParallelIterator for Chain<A, B> where
A: ParallelIterator,
B: ParallelIterator<Item = <A as ParallelIterator>::Item>, type Item = <A as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, [src]
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, type Item = &'a mut T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I> ParallelIterator for MaxLen<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for MaxLen<I> where
I: IndexedParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'data, T, P> ParallelIterator for SplitMut<'data, T, P> where
P: Fn(&T) -> bool + Sync + Send,
T: Send, [src]
impl<'data, T, P> ParallelIterator for SplitMut<'data, T, P> where
P: Fn(&T) -> bool + Sync + Send,
T: Send, type Item = &'data mut [T]
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'ch, P> ParallelIterator for Split<'ch, P> where
P: Pattern, [src]
impl<'ch, P> ParallelIterator for Split<'ch, P> where
P: Pattern, type Item = &'ch str
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<A, B> ParallelIterator for Zip<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator, [src]
impl<A, B> ParallelIterator for Zip<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator, type Item = (<A as ParallelIterator>::Item, <B as ParallelIterator>::Item)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<L, R> ParallelIterator for Either<L, R> where
L: ParallelIterator,
R: ParallelIterator<Item = <L as ParallelIterator>::Item>, [src]
impl<L, R> ParallelIterator for Either<L, R> where
L: ParallelIterator,
R: ParallelIterator<Item = <L as ParallelIterator>::Item>, Either<L, R> is a parallel iterator if both L and R are parallel iterators.
type Item = <L as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, K, V> ParallelIterator for IterMut<'a, K, V> where
K: 'a + Sync + Eq + Hash,
V: 'a + Send, [src]
impl<'a, K, V> ParallelIterator for IterMut<'a, K, V> where
K: 'a + Sync + Eq + Hash,
V: 'a + Send, type Item = (&'a K, &'a mut V)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'data, T> ParallelIterator for Chunks<'data, T> where
T: 'data + Sync, [src]
impl<'data, T> ParallelIterator for Chunks<'data, T> where
T: 'data + Sync, type Item = &'data [T]
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, P, R> ParallelIterator for FilterMap<I, P> where
I: ParallelIterator,
P: Fn(<I as ParallelIterator>::Item) -> Option<R> + Sync + Send,
R: Send, [src]
impl<I, P, R> ParallelIterator for FilterMap<I, P> where
I: ParallelIterator,
P: Fn(<I as ParallelIterator>::Item) -> Option<R> + Sync + Send,
R: Send, type Item = R
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl ParallelIterator for Iter<u64>[src]
impl ParallelIterator for Iter<u64>type Item = u64
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch> ParallelIterator for EncodeUtf16<'ch>[src]
impl<'ch> ParallelIterator for EncodeUtf16<'ch>type Item = u16
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'data, T> ParallelIterator for Windows<'data, T> where
T: 'data + Sync, [src]
impl<'data, T> ParallelIterator for Windows<'data, T> where
T: 'data + Sync, type Item = &'data [T]
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<u16>[src]
impl ParallelIterator for Iter<u16>type Item = u16
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<U, I, ID, F> ParallelIterator for TryFold<I, U, ID, F> where
F: Fn(<U as Try>::Ok, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
ID: Fn() -> <U as Try>::Ok + Sync + Send,
U: Try + Send, [src]
impl<U, I, ID, F> ParallelIterator for TryFold<I, U, ID, F> where
F: Fn(<U as Try>::Ok, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
ID: Fn() -> <U as Try>::Ok + Sync + Send,
U: Try + Send, type Item = U
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, [src]
impl<'a, T> ParallelIterator for IterMut<'a, T> where
T: 'a + Send, type Item = &'a mut T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch, P> ParallelIterator for SplitTerminator<'ch, P> where
P: Pattern, [src]
impl<'ch, P> ParallelIterator for SplitTerminator<'ch, P> where
P: Pattern, type Item = &'ch str
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'ch> ParallelIterator for Bytes<'ch>[src]
impl<'ch> ParallelIterator for Bytes<'ch>type Item = u8
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<U, I, ID, F> ParallelIterator for Fold<I, ID, F> where
F: Fn(U, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
ID: Fn() -> U + Sync + Send,
U: Send, [src]
impl<U, I, ID, F> ParallelIterator for Fold<I, ID, F> where
F: Fn(U, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
ID: Fn() -> U + Sync + Send,
U: Send, type Item = U
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'data, T> ParallelIterator for IterMut<'data, T> where
T: 'data + Send, [src]
impl<'data, T> ParallelIterator for IterMut<'data, T> where
T: 'data + Send, type Item = &'data mut T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I> ParallelIterator for Rev<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for Rev<I> where
I: IndexedParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, F> ParallelIterator for Update<I, F> where
F: Fn(&mut <I as ParallelIterator>::Item) + Send + Sync,
I: ParallelIterator, [src]
impl<I, F> ParallelIterator for Update<I, F> where
F: Fn(&mut <I as ParallelIterator>::Item) + Send + Sync,
I: ParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch, P> ParallelIterator for MatchIndices<'ch, P> where
P: Pattern, [src]
impl<'ch, P> ParallelIterator for MatchIndices<'ch, P> where
P: Pattern, type Item = (usize, &'ch str)
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<T> ParallelIterator for Once<T> where
T: Send, [src]
impl<T> ParallelIterator for Once<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I> ParallelIterator for Intersperse<I> where
I: ParallelIterator,
<I as ParallelIterator>::Item: Clone,
<I as ParallelIterator>::Item: Send, [src]
impl<I> ParallelIterator for Intersperse<I> where
I: ParallelIterator,
<I as ParallelIterator>::Item: Clone,
<I as ParallelIterator>::Item: Send, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<Iter> ParallelIterator for IterBridge<Iter> where
Iter: Send + Iterator,
<Iter as Iterator>::Item: Send, [src]
impl<Iter> ParallelIterator for IterBridge<Iter> where
Iter: Send + Iterator,
<Iter as Iterator>::Item: Send, type Item = <Iter as Iterator>::Item
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl ParallelIterator for Iter<usize>[src]
impl ParallelIterator for Iter<usize>type Item = usize
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, INIT, T, F, R> ParallelIterator for MapInit<I, INIT, F> where
F: Fn(&mut T, <I as ParallelIterator>::Item) -> R + Sync + Send,
I: ParallelIterator,
INIT: Fn() -> T + Sync + Send,
R: Send, [src]
impl<I, INIT, T, F, R> ParallelIterator for MapInit<I, INIT, F> where
F: Fn(&mut T, <I as ParallelIterator>::Item) -> R + Sync + Send,
I: ParallelIterator,
INIT: Fn() -> T + Sync + Send,
R: Send, type Item = R
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<u128>[src]
impl ParallelIterator for Iter<u128>type Item = u128
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<u8>[src]
impl ParallelIterator for Iter<u8>type Item = u8
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, J> ParallelIterator for InterleaveShortest<I, J> where
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, [src]
impl<I, J> ParallelIterator for InterleaveShortest<I, J> where
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch, P> ParallelIterator for Matches<'ch, P> where
P: Pattern, [src]
impl<'ch, P> ParallelIterator for Matches<'ch, P> where
P: Pattern, type Item = &'ch str
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'data, T, P> ParallelIterator for Split<'data, T, P> where
P: Fn(&T) -> bool + Sync + Send,
T: Sync, [src]
impl<'data, T, P> ParallelIterator for Split<'data, T, P> where
P: Fn(&T) -> bool + Sync + Send,
T: Sync, type Item = &'data [T]
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<I, P> ParallelIterator for Filter<I, P> where
I: ParallelIterator,
P: Fn(&<I as ParallelIterator>::Item) -> bool + Sync + Send, [src]
impl<I, P> ParallelIterator for Filter<I, P> where
I: ParallelIterator,
P: Fn(&<I as ParallelIterator>::Item) -> bool + Sync + Send, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<I> ParallelIterator for Enumerate<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for Enumerate<I> where
I: IndexedParallelIterator, type Item = (usize, <I as ParallelIterator>::Item)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<isize>[src]
impl ParallelIterator for Iter<isize>type Item = isize
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<D, S> ParallelIterator for Split<D, S> where
D: Send,
S: Fn(D) -> (D, Option<D>) + Sync + Send, [src]
impl<D, S> ParallelIterator for Split<D, S> where
D: Send,
S: Fn(D) -> (D, Option<D>) + Sync + Send, type Item = D
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'ch> ParallelIterator for Lines<'ch>[src]
impl<'ch> ParallelIterator for Lines<'ch>type Item = &'ch str
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<K, V> ParallelIterator for IntoIter<K, V> where
K: Send + Eq + Hash,
V: Send, [src]
impl<K, V> ParallelIterator for IntoIter<K, V> where
K: Send + Eq + Hash,
V: Send, type Item = (K, V)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<A, B> ParallelIterator for ZipEq<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator, [src]
impl<A, B> ParallelIterator for ZipEq<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator, type Item = (<A as ParallelIterator>::Item, <B as ParallelIterator>::Item)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync + Ord, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync + Ord, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<u32>[src]
impl ParallelIterator for Iter<u32>type Item = u32
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, PI> ParallelIterator for Flatten<I> where
I: ParallelIterator<Item = PI>,
PI: IntoParallelIterator + Send, [src]
impl<I, PI> ParallelIterator for Flatten<I> where
I: ParallelIterator<Item = PI>,
PI: IntoParallelIterator + Send, type Item = <PI as IntoParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'a, K, V> ParallelIterator for Iter<'a, K, V> where
K: 'a + Sync + Eq + Hash,
V: 'a + Sync, [src]
impl<'a, K, V> ParallelIterator for Iter<'a, K, V> where
K: 'a + Sync + Eq + Hash,
V: 'a + Sync, type Item = (&'a K, &'a V)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I> ParallelIterator for Skip<I> where
I: IndexedParallelIterator, [src]
impl<I> ParallelIterator for Skip<I> where
I: IndexedParallelIterator, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T, I> ParallelIterator for Cloned<I> where
I: ParallelIterator<Item = &'a T>,
T: 'a + Clone + Send + Sync, [src]
impl<'a, T, I> ParallelIterator for Cloned<I> where
I: ParallelIterator<Item = &'a T>,
T: 'a + Clone + Send + Sync, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, K, V> ParallelIterator for IterMut<'a, K, V> where
K: 'a + Sync + Ord,
V: 'a + Send, [src]
impl<'a, K, V> ParallelIterator for IterMut<'a, K, V> where
K: 'a + Sync + Ord,
V: 'a + Send, type Item = (&'a K, &'a mut V)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for RepeatN<T> where
T: Clone + Send, [src]
impl<T> ParallelIterator for RepeatN<T> where
T: Clone + Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'ch> ParallelIterator for Chars<'ch>[src]
impl<'ch> ParallelIterator for Chars<'ch>type Item = char
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<i16>[src]
impl ParallelIterator for Iter<i16>type Item = i16
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<i64>[src]
impl ParallelIterator for Iter<i64>type Item = i64
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<U, I, F> ParallelIterator for TryFoldWith<I, U, F> where
F: Fn(<U as Try>::Ok, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
U: Try + Send,
<U as Try>::Ok: Clone,
<U as Try>::Ok: Send, [src]
impl<U, I, F> ParallelIterator for TryFoldWith<I, U, F> where
F: Fn(<U as Try>::Ok, <I as ParallelIterator>::Item) -> U + Sync + Send,
I: ParallelIterator,
U: Try + Send,
<U as Try>::Ok: Clone,
<U as Try>::Ok: Send, type Item = U
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<I, J> ParallelIterator for Interleave<I, J> where
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, [src]
impl<I, J> ParallelIterator for Interleave<I, J> where
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = <I as ParallelIterator>::Item>, type Item = <I as ParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, F, R> ParallelIterator for Map<I, F> where
F: Fn(<I as ParallelIterator>::Item) -> R + Sync + Send,
I: ParallelIterator,
R: Send, [src]
impl<I, F, R> ParallelIterator for Map<I, F> where
F: Fn(<I as ParallelIterator>::Item) -> R + Sync + Send,
I: ParallelIterator,
R: Send, type Item = <F as FnOnce(<I as ParallelIterator>::Item)>::Output
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, T, F, R> ParallelIterator for MapWith<I, T, F> where
F: Fn(&mut T, <I as ParallelIterator>::Item) -> R + Sync + Send,
I: ParallelIterator,
R: Send,
T: Send + Clone, [src]
impl<I, T, F, R> ParallelIterator for MapWith<I, T, F> where
F: Fn(&mut T, <I as ParallelIterator>::Item) -> R + Sync + Send,
I: ParallelIterator,
R: Send,
T: Send + Clone, type Item = R
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for Repeat<T> where
T: Clone + Send, [src]
impl<T> ParallelIterator for Repeat<T> where
T: Clone + Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<T> ParallelIterator for Empty<T> where
T: Send, [src]
impl<T> ParallelIterator for Empty<T> where
T: Send, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<i8>[src]
impl ParallelIterator for Iter<i8>type Item = i8
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl ParallelIterator for Iter<i128>[src]
impl ParallelIterator for Iter<i128>type Item = i128
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, K, V> ParallelIterator for Iter<'a, K, V> where
K: 'a + Sync + Ord,
V: 'a + Sync, [src]
impl<'a, K, V> ParallelIterator for Iter<'a, K, V> where
K: 'a + Sync + Ord,
V: 'a + Sync, type Item = (&'a K, &'a V)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<I, F, PI> ParallelIterator for FlatMap<I, F> where
F: Fn(<I as ParallelIterator>::Item) -> PI + Sync + Send,
I: ParallelIterator,
PI: IntoParallelIterator, [src]
impl<I, F, PI> ParallelIterator for FlatMap<I, F> where
F: Fn(<I as ParallelIterator>::Item) -> PI + Sync + Send,
I: ParallelIterator,
PI: IntoParallelIterator, type Item = <PI as IntoParallelIterator>::Item
fn drive_unindexed<C>( | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync + Eq + Hash, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync + Eq + Hash, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<K, V> ParallelIterator for IntoIter<K, V> where
K: Send + Ord,
V: Send, [src]
impl<K, V> ParallelIterator for IntoIter<K, V> where
K: Send + Ord,
V: Send, type Item = (K, V)
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<T> ParallelIterator for IntoIter<T> where
T: Send + Eq + Hash, [src]
impl<T> ParallelIterator for IntoIter<T> where
T: Send + Eq + Hash, type Item = T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, [src]
impl<'a, T> ParallelIterator for Iter<'a, T> where
T: 'a + Sync, type Item = &'a T
fn drive_unindexed<C>( | [src] |
fn opt_len(&self) -> Option<usize> | [src] |
fn for_each<OP>(self, op: OP) where | [src] |
fn for_each_with<OP, T>(self, init: T, op: OP) where | [src] |
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where | [src] |
fn try_for_each<OP, R>(self, op: OP) -> R where | [src] |
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where | [src] |
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where | [src] |
fn count(self) -> usize | [src] |
fn map<F, R>(self, map_op: F) -> Map<Self, F> where | [src] |
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where | [src] |
fn map_init<F, INIT, T, R>( | [src] |
fn cloned<'a, T>(self) -> Cloned<Self> where | [src] |
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where | [src] |
fn update<F>(self, update_op: F) -> Update<Self, F> where | [src] |
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where | [src] |
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where | [src] |
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where | [src] |
fn flatten(self) -> Flatten<Self> where | [src] |
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where | [src] |
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where | [src] |
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where | [src] |
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where | [src] |
fn try_fold<T, R, ID, F>( | [src] |
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where | [src] |
fn sum<S>(self) -> S where | [src] |
fn product<P>(self) -> P where | [src] |
fn min(self) -> Option<Self::Item> where | [src] |
fn min_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max(self) -> Option<Self::Item> where | [src] |
fn max_by<F>(self, f: F) -> Option<Self::Item> where | [src] |
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where | [src] |
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter> where | [src] |
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
fn find<P>(self, predicate: P) -> Option<Self::Item> where | [src] |
parallel find does not search in order -- use find_any,
find_first, or find_last
fn any<P>(self, predicate: P) -> bool where | [src] |
fn all<P>(self, predicate: P) -> bool where | [src] |
fn while_some<T>(self) -> WhileSome<Self> where | [src] |
fn collect<C>(self) -> C where | [src] |
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where | [src] |
fn partition<A, B, P>(self, predicate: P) -> (A, B) where | [src] |
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where | [src] |
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where | [src] |